Implements accepted proposal 0063 (spec v0.69.0): makes a caller's tool execution observable. This is the execution-side complement to 0076 (the request side), joined by tool_call_id, and the last feature of the v0.15.0 cycle. Pin advances v0.68.0 to v0.69.0 (0063 is the only proposal in the delta).

The primitive

A model requests tools in its completion; the caller executes them in node-body code (OpenArmature does not run, select, loop, or feed back tools), so that execution was invisible to the observer stream. with_tool_call is a node-body instrumentation scope, a context manager modeled on with_active_prompt:

from openarmature.observability import with_tool_call

with with_tool_call("get_weather", {"city": "Paris"}, tool_call_id="call_abc") as scope:
    result = await get_weather(city="Paris")
    scope.set_result(result)

You run the tool inside it and report the outcome with scope.set_result(...). On a clean exit it dispatches a ToolCallEvent; if the tool raises, it dispatches a ToolCallFailedEvent and re-raises (it observes, it does not swallow). I chose the context-manager shape over an inline-wrapping helper to stay consistent with the existing with_active_prompt node-body primitives.

The events

Two typed variants on the graph-engine observer union, mirroring the LLM completion/failure pairing. Both carry the identity/scoping baseline plus tool_name, tool_call_id (the link back to the requesting LlmCompletionEvent.output_tool_calls entry, or null for a standalone instrumented function), arguments, latency_ms, and call_id. ToolCallEvent adds result; ToolCallFailedEvent adds error_type / error_message and deliberately carries no error_category (tool code is arbitrary, with no closed failure taxonomy).

Rendering

• OTel: an openarmature.tool.call span (note .call, not .complete) parented under the calling node, with OA-namespace openarmature.tool.{name,call.id,call.arguments,call.result} attributes and the standard error.type on failure. The Development gen_ai.tool.* / execute_tool surface is mirrored, not emitted in v1, so a future cutover is a prefix swap.
• Langfuse: a dedicated Tool observation (asType="tool", not a Generation) under the node's Span observation, with arguments / result as input / output and the tool name / call id in metadata, ERROR level on failure. This is python's first non-Span/Generation observation type, so tool() was added to the client Protocol, the in-memory recorder, and the SDK adapter.

arguments and result are payload, gated by disable_provider_payload (no new flag); disable_llm_spans does not gate the tool span.

Two fixes from the self-review

• Payload serialization in both observers now uses default=str, so an opaque tool result that JSON cannot natively encode (a Pydantic model, a datetime) renders via its str() instead of raising inside the observer and losing the whole span/observation.
• The Langfuse SDK adapter now back-dates the Tool observation (generalized the back-dating helper to wrap LangfuseTool), so the live observation's duration reflects the tool latency, matching the Generation path.

Scope

v1 ships the inline bracketing form only. The deferred start/complete split (a tool result landing in a later turn) is a spec MAY with no fixture, deferred until a consumer needs event-driven tool execution; inline-only is fully conformant.

Tests

• Unit: the primitive (dispatch, re-raise, tool_call_id linkage, the serialization fallback), the OTel span, the Langfuse Tool observation, and the adapter back-dating (verified against the mock SDK).
• Conformance: fixtures 092-098 run through a tool-graph runner (092-095 typed-event-collector, 096/097 OTel span_tree, 098 Langfuse Tool observation). The fixture-parser schema gained the calls_tool directive and the record state type; 092-095 defer-parse like the 050-056 typed-collector fixtures.
• Full suite green; ruff + pyright clean; mkdocs build --strict clean.